#!/usr/bin/python3

"""
基本数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中[对象的类型]。
"""

counter = 100  # 整型变量
miles = 1000.0  # 浮点型变量
name = "runoob"  # 字符串
#  同时为多个变量赋值
var1 = var2 = "hello"

print(counter)
print(miles)
print(name)
print(var1 + " " + var2)

"""
标准数据类型
Python3 中有六个标准的数据类型：
像大多数语言一样，数值类型的赋值和计算都是很直观的。
"""
print("----------------------DATATYPE---------------------")
a, b, c, d = 20, 5.5, True, 4 + 3j
# 内置的 type() 函数可以用来查询变量所指的对象类型。
print(type(a), type(b), type(c), type(d))
# 可以用 isinstance 来判断类型
print(isinstance(a, int), isinstance(a, float), isinstance(c, bool), isinstance(d, complex))


class A:
    pass


class B(A):
    pass


# 区别是：type不会认为子类是一种父类类型。 isinstance会认为子类是一种父类类型。
print(isinstance(A(), A), isinstance(B(), A), type(A()) == A, type(B()) == A)

print("----------------------NUMBER---------------------")
"""
1.Number（数字）
4种数据类型： int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

当你指定一个值时，Number 对象就会被创建
您也可以使用del语句删除一些对象引用。
"""
del a, b, c, d

# 数值运算(取浮点数除法，取整数除法，取余，乘方)
# 数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
# 在混合计算时，Python会把整型转换成为浮点数
print(4 / 2, 2 / 4, 2 // 4, 17 % 3, 2 ** 5)

print("----------------------STRING---------------------")
"""
String（字符串）
Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。
字符串的截取的语法格式如下：(索引值以 0 为开始值，-1 为从末尾的开始位置。,不把尾下表算在内)

  变量[头下标:尾下标]

加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数
"""
pystr = 'Runoob'

print(pystr)  # 输出字符串
print(pystr[0:-1])  # 输出第一个到倒数第二个的所有字符
print(pystr[0])  # 输出字符串第一个字符
print(pystr[2:5])  # 输出从第三个开始到第五个的字符
print(pystr[2:])  # 输出从第三个开始的后的所有字符
print(pystr * 2)  # 输出字符串两次
print(pystr + "TEST")  # 连接字符串

# Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
print('Ru\noo\tb', r'Ru\noob')
# 另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
print('hello \
world')
print("""
hello world
""", '''
hello world
''')
# 注意：Python中的字符串不能改变

print("----------------------LIST---------------------")
"""
List（列表）
List 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号([])之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
  变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号（+）是列表连接运算符，星号（*）是重复操作
"""
pylist = ['abcd', 786, 2.23, 'runoob', 70.2]
tinylist = [123, 'runoob']

print(pylist)  # 输出完整列表
print(pylist[0])  # 输出列表第一个元素
print(pylist[1:3])  # 从第二个开始输出到第三个元素
print(pylist[2:])  # 输出从第三个元素开始的所有元素
print(tinylist * 2)  # 输出两次列表
print(pylist + tinylist)  # 连接列表
# List中的元素是可以改变的
a = [1, 2, 3, 4, 5, 6]
a[0] = 9
a[2:5] = [13, 14, 15]
print(a)

# 删除元素
del a[0]
a[1:4] = []
print(a)

print("----------------------TUPLE---------------------")
"""
Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看下面，这里不再赘述）。
其实，可以把字符串看作一种特殊的元组
"""
pytuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')

print(pytuple)  # 输出完整元组
print(pytuple[0])  # 输出元组的第一个元素
print(pytuple[1:3])  # 输出从第二个元素开始到第三个元素
print(pytuple[2:])  # 输出从第三个元素开始的所有元素
print(tinytuple * 2)  # 输出两次元组
print(pytuple + tinytuple)  # 连接元组

# 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
# 构造包含 0 个或 1 个元素的元组（需要在元素后添加逗号）比较特殊，所以有一些额外的语法规则：
tup1 = ()
tup2 = (20,)
print(tup1, tup2, type(tup1))

# string、list和tuple都属于sequence（序列）
print("String List Tuple belone to Sequence")
"""
Sets（集合）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
"""
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
alpha = set("ABCC")
tclist = ["Zhang", "Lee"]
teacher = set(tclist)

print(student, alpha, teacher)  # 输出集合，重复的元素被自动去掉

# 成员测试
print("Rose" in student, "Rosen" in student)

print("----------------------DICTIONARY---------------------")
"""
Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
字典是一种映射类型，它的元素是键值对
字典的关键字必须为不可变类型，且不能重复
创建空字典使用 { }
"""
pydict = {}
pydict['one'] = "hello"
pydict[2] = "world"
tinydict = {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print(pydict['one'])  # 输出键为 'one' 的值
print(pydict[2])  # 输出键为 2 的值
print(tinydict)  # 输出完整的字典
print(tinydict.keys(), type(tinydict.keys()))  # 输出所有键
print(tinydict.values(), type(tinydict.values()))  # 输出所有值
# 构造函数 dict() 可以直接从键值对序列中构建字典如下
pydict2 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
print("pydict2 is : ", pydict2)

pydict3 = {x: x ** 2 for x in (2, 4, 6)}
print("pydict3 is : ", pydict3)
pydict4 = dict(Runoob=1, Google=2, Taobao=3)
print("pydict4 is : ", pydict4)
# 可以认定为两部分
pydict3 = {x: (x + "'s ASCII is :" + str(ord(x))) for x in ("L", "I", "N")}
print("pydict3 is : ", pydict3)

print("----------------------TYPE CONVERSION---------------------")
# 类型转换
"""
int(x [,base]) 将x转换为一个整数
class int(x, base=10)
x -- 字符串或数字。
base -- 进制数，默认十进制。
int() 函数用于将一个字符串会数字转换为整型（十进制）。
x -- 字符串或数字。
base -- 进制数，默认十进制。( 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制,即 参数二声明的是参数一代表的进制值)
"""
print(int(121), int(3.6), int('12', 16), int('0xa', 16), int('10', 8))
"""
float(x) 将x转换到一个浮点数
class float([x])
x -- 整数或字符串
用于将整数和字符串转换成浮点数,已经是浮点数的保持不变。
"""
print(float(1), float(-123.6), float('123'))
"""
complex(real [,imag]) 创建一个复数
class complex([real[, imag]])
real -- int, long, float或字符串；
imag -- int, long, float；
创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
"""
print(complex(1, 2), complex(1), complex("1"), complex("1+2j"))
"""
str(x) 将对象 x 转换为字符串
str() 函数将对象转化为适于人阅读的形式
class str(object='') : object -- 对象;回一个对象的string格式。
"""
s = 'RUNOOB'
d = {'runoob': 'runoob.com', 'google': 'google.com'}
print(str(s), str(d))
"""
repr(x) 将对象 x 转换为表达式字符串
class repr(object) : 返回一个对象的 string 格式。
"""
s = 'RUNOOB'
d = {'runoob': 'runoob.com', 'google': 'google.com'};
print(repr(s), repr(d))
"""
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
eval(expression[, globals[, locals]]) : 返回表达式计算结果。
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
"""
x = 7
print(eval('3 * x'), eval('pow(2,2)'))

# tuple( seq ) :  将序列 s 转换为一个元组
# seq -- 要转换为元组的序列。
alist = ['Google', 'Taobao', 'Runoob', 'Baidu']
print("List to Tuple :", tuple(alist))
astr = "hello world"
print("String to Tuple", tuple(astr))
"""
list(seq) 将序列 seq 转换为一个列表
元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中
seq -- 要转换为列表的元组。
"""
t = (123, 'Google', 'Runoob', 'Taobao')
print("Tuple to List : ", list(t))
s = "Hello World"
print("String to List : ", list(s))
"""
set(s) 转换为可变集合(该函数还可以创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等)
class set([iterable])：　返回新的集合对象。　
iterable -- 可迭代对象对象；
"""
rset = set('runoob')
glist = ["g", 'o', 'o', 'g', 'l', 'e']
gset = set(glist)
# 重复的已经被删除
print(rset, gset)
# 交集 并集 差集
print("& :", rset & gset)
print("| :", rset | gset)
print("- :", rset - gset)
"""
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
class dict(**kwarg) : **kwargs -- 关键字
class dict(mapping, **kwarg) : mapping -- 元素的容器。
class dict(iterable, **kwarg) : mapping -- 元素的容器。
"""
# 关键字
print(dict(a='a', b='b', t='t'))
# 映射函数方式
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))
# 可迭代对象方式
print(dict([('one', 1), ('two', 2), ('three', 3)]))
"""
frozenset(iterable) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。。
"""
print(frozenset(range(10)))
print(frozenset('runoob'))
"""
chr(i) 将一个整数转换为一个字符
用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符
unichr(i) unichr() 函数 和 chr()函数功能基本一样， 只不过是返回 unicode 的字符
注意：Python3中不在区分可以使用chr代替unichr的功能
"""
print(chr(0x30), chr(0x31), chr(0x61))
print(chr(48), chr(49), chr(97), type(chr(97)))
print(chr(0x3120))
"""
ord(x) 将一个字符转换为它的整数值
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，
返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
返回值是对应的十进制整数。
"""
print(ord('中'))

# hex(int):string 将一个整数转换为一个十六进制字符串
print(hex(255), type(hex(255)))
# oct(x) 将一个整数转换为一个八进制字符串
print(oct(20), type(oct(20)))
